import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { login as loginApi, logout as logoutApi } from '@/api/auth'
import { getUserInfo, getUserPermissions, getUserMenus } from '@/api/auth'

export const useAuthStore = defineStore('auth', () => {
  // 从localStorage或sessionStorage读取数据
  const getStoredToken = () => {
    // 检查是否有记住我标志
    const isRememberMe = localStorage.getItem('rememberMe') === 'true'
    if (isRememberMe) {
      // 记住我：优先从localStorage读取
      return localStorage.getItem('token') || ''
    } else {
      // 不记住我：从sessionStorage读取
      return sessionStorage.getItem('token') || ''
    }
  }
  
  const getStoredUser = () => {
    const isRememberMe = localStorage.getItem('rememberMe') === 'true'
    let userStr = '{}'
    if (isRememberMe) {
      userStr = localStorage.getItem('user') || '{}'
    } else {
      userStr = sessionStorage.getItem('user') || '{}'
    }
    return JSON.parse(userStr)
  }
  
  // 修复：权限和菜单初始化时不读取存储数据，避免权限污染
  const getStoredPermissions = () => {
    // 初始化时不读取存储的权限数据，避免权限污染
    // 权限数据应该在每次登录后重新获取
    return []
  }
  
  const getStoredMenus = () => {
    // 初始化时不读取存储的菜单数据，避免菜单污染
    // 菜单数据应该在每次登录后重新获取
    return []
  }
  
  const token = ref(getStoredToken())
  const user = ref(getStoredUser())
  const permissions = ref(getStoredPermissions())
  const menus = ref(getStoredMenus())
  
  const isAuthenticated = computed(() => !!token.value)
  const isLoggedIn = computed(() => !!token.value)
  
  // 登录
  const login = async (loginData) => {
    try {
      console.log('开始登录流程...')
      
      // 先清除之前的登录状态和权限
      clearAuthData()
      
      const response = await loginApi(loginData)
      
      if (response.data.code === 200) {
        const { token: tokenValue, user: userData } = response.data.data
        
        console.log('登录成功，用户信息:', userData.username)
        console.log('用户详细信息:', userData)
        
        // 设置token和用户信息
        token.value = tokenValue
        user.value = { ...userData }  // 使用解构赋值确保数据完整性
        
        // 根据"记住我"选项决定存储方式
        if (loginData.rememberMe) {
          // 使用localStorage（持久化存储）
          localStorage.setItem('token', tokenValue)
          localStorage.setItem('user', JSON.stringify(userData))
          localStorage.setItem('rememberMe', 'true')
        } else {
          // 使用sessionStorage（会话存储）
          sessionStorage.setItem('token', tokenValue)
          sessionStorage.setItem('user', JSON.stringify(userData))
          localStorage.removeItem('rememberMe')
        }
        
        // 验证用户信息是否正确设置
        console.log('设置后的用户状态:', user.value)
        console.log('设置后的token状态:', token.value)
        
        // 强制获取用户权限和菜单（确保数据是最新的）
        console.log('开始获取用户权限和菜单...')
        await fetchUserPermissions()
        await fetchUserMenus()
        await fetchUserRoles()
        
        // 验证权限状态是否正确更新
        console.log('登录完成，最终权限状态:', permissions.value)
        console.log('登录完成，最终菜单状态:', menus.value)
        console.log('登录完成，最终用户状态:', user.value)
        
        // 最终验证
        if (!permissions.value || permissions.value.length === 0) {
          console.warn('警告：权限数据为空，可能存在权限获取问题')
        } else {
          console.log('权限数据获取成功，权限数量:', permissions.value.length)
        }
        
        return { success: true }
      } else {
        return { success: false, message: response.data.message }
      }
    } catch (error) {
      console.error('登录失败:', error)
      
      // 优先显示后端返回的具体错误信息
      if (error.response && error.response.data && error.response.data.message) {
        return { success: false, message: error.response.data.message }
      }
      
      // 如果是网络错误或其他错误，才显示通用错误信息
      return { success: false, message: '登录失败，请检查网络连接' }
    }
  }

  // 清除认证数据（完全修复函数）
  const clearAuthData = () => {
    console.log('开始清理认证数据...')
    
    // 强制重置内存中的状态
    token.value = ''
    user.value = {}
    permissions.value = []
    menus.value = []
    
    // 清除localStorage中的所有认证相关数据
    localStorage.removeItem('token')
    localStorage.removeItem('user')
    localStorage.removeItem('permissions')
    localStorage.removeItem('menus')
    localStorage.removeItem('rememberMe')
    
    // 清除sessionStorage中的所有认证相关数据
    sessionStorage.removeItem('token')
    sessionStorage.removeItem('user')
    sessionStorage.removeItem('permissions')
    sessionStorage.removeItem('menus')
    
    // 强制清理可能存在的其他权限相关数据
    localStorage.removeItem('auth_token')
    localStorage.removeItem('auth_user')
    localStorage.removeItem('auth_permissions')
    localStorage.removeItem('auth_menus')
    
    sessionStorage.removeItem('auth_token')
    sessionStorage.removeItem('auth_user')
    sessionStorage.removeItem('auth_permissions')
    sessionStorage.removeItem('auth_menus')
    
    // 清理所有可能的权限相关键
    const allKeys = Object.keys(localStorage)
    allKeys.forEach(key => {
      if (key.includes('permission') || key.includes('auth') || key.includes('token') || key.includes('user') || key.includes('menu')) {
        localStorage.removeItem(key)
        console.log('清理localStorage键:', key)
      }
    })
    
    const allSessionKeys = Object.keys(sessionStorage)
    allSessionKeys.forEach(key => {
      if (key.includes('permission') || key.includes('auth') || key.includes('token') || key.includes('user') || key.includes('menu')) {
        sessionStorage.removeItem(key)
        console.log('清理sessionStorage键:', key)
      }
    })
    
    console.log('认证数据清理完成')
    
    // 注意：保留账号密码信息（savedUsername, savedPassword, savedRememberMe）
    // 这些是用户手动保存的登录信息，不应该被清除
  }

  // 获取用户权限
  const fetchUserPermissions = async () => {
    try {
      console.log('开始获取用户权限...')
      console.log('当前用户信息:', user.value)
      
      // 先清理之前的权限数据
      permissions.value = []
      
      // 确保有用户信息
      if (!user.value || !user.value.username) {
        console.error('用户信息不完整，无法获取权限')
        return
      }
      
      const response = await getUserPermissions()
      
      if (response.data.code === 200) {
        // 确保权限数据是最新的
        const newPermissions = response.data.data || []
        console.log('获取到的权限:', newPermissions)
        console.log('权限数量:', newPermissions.length)
        
        // 强制更新权限状态
        permissions.value = [...newPermissions]
        
        // 强制使用当前登录状态，不依赖存储的rememberMe
        const currentRememberMe = localStorage.getItem('rememberMe') === 'true'
        console.log('当前记住我状态:', currentRememberMe)
        
        if (currentRememberMe) {
          localStorage.setItem('permissions', JSON.stringify(newPermissions))
          console.log('权限已保存到localStorage')
        } else {
          sessionStorage.setItem('permissions', JSON.stringify(newPermissions))
          console.log('权限已保存到sessionStorage')
        }
        
        // 验证权限状态是否正确更新
        console.log('权限状态更新后验证:', permissions.value)
        console.log('权限状态长度:', permissions.value.length)
        
        // 检查关键权限
        const hasUserAdd = permissions.value.includes('system:user:add')
        const hasUserEdit = permissions.value.includes('system:user:edit')
        const hasUserDelete = permissions.value.includes('system:user:delete')
        console.log('权限检查结果:', {
          'system:user:add': hasUserAdd,
          'system:user:edit': hasUserEdit,
          'system:user:delete': hasUserDelete
        })
      } else {
        // 如果获取权限失败，清空权限
        permissions.value = []
        localStorage.removeItem('permissions')
        sessionStorage.removeItem('permissions')
        console.log('权限获取失败，已清空')
      }
    } catch (error) {
      console.error('获取用户权限失败:', error)
      // 出错时清空权限
      permissions.value = []
      localStorage.removeItem('permissions')
      sessionStorage.removeItem('permissions')
      console.log('权限获取异常，已清空')
    }
  }

  // 获取用户菜单
  const fetchUserMenus = async () => {
    try {
      console.log('开始获取用户菜单...')
      
      // 先清理之前的菜单数据
      menus.value = []
      
      const response = await getUserMenus()
      
      if (response.data.code === 200) {
        // 确保菜单数据是最新的
        menus.value = response.data.data || []
        console.log('获取到的菜单:', menus.value)
        
        // 强制使用当前登录状态，不依赖存储的rememberMe
        const currentRememberMe = localStorage.getItem('rememberMe') === 'true'
        console.log('当前记住我状态:', currentRememberMe)
        
        if (currentRememberMe) {
          localStorage.setItem('menus', JSON.stringify(menus.value))
          console.log('菜单已保存到localStorage')
        } else {
          sessionStorage.setItem('menus', JSON.stringify(menus.value))
          console.log('菜单已保存到sessionStorage')
        }
      } else {
        // 如果获取菜单失败，清空菜单
        menus.value = []
        localStorage.removeItem('permissions')
        sessionStorage.removeItem('permissions')
        console.log('菜单获取失败，已清空')
      }
    } catch (error) {
      console.error('获取用户菜单失败:', error)
      // 出错时清空菜单
      menus.value = []
      localStorage.removeItem('permissions')
      sessionStorage.removeItem('permissions')
      console.log('菜单获取异常，已清空')
    }
  }

  // 获取用户角色
  const fetchUserRoles = async () => {
    try {
      // 从用户信息中获取角色名称
      if (user.value && user.value.roleNames && user.value.roleNames.length > 0) {
        // 用户信息中已包含角色信息
      } else {
        // 用户信息中没有角色信息，需要从后端获取
        // 这里可以添加从后端获取用户角色的逻辑
      }
    } catch (error) {
      console.error('获取用户角色失败:', error)
    }
  }
  
  const hasPermission = (permissionCode) => {
    // 检查权限数据是否有效
    if (!permissions.value || permissions.value.length === 0) {
      return false
    }
    
    // 检查权限代码格式
    if (!permissionCode || typeof permissionCode !== 'string') {
      return false
    }
    
    return permissions.value.includes(permissionCode)
  }
  
  const hasAnyPermission = (permissionCodes) => {
    return permissionCodes.some(code => permissions.value.includes(code))
  }
  
  const hasAllPermissions = (permissionCodes) => {
    return permissionCodes.every(code => permissions.value.includes(code))
  }
  
  const logout = async () => {
    try {
      // 调用后端登出接口，清理Spring Security上下文
      const response = await logoutApi()
      if (response && response.data && response.data.code === 200) {
        // 后端登出接口调用成功
      } else {
        console.warn('后端登出接口调用失败:', response?.data?.message || '未知错误')
      }
      
    } catch (error) {
      console.error('调用后端登出接口失败:', error)
    }
    
    // 使用统一的清理函数
    clearAuthData()
    
    // 强制清理可能残留的权限数据
    const keysToRemove = [
      'token', 'user', 'permissions', 'menus', 'rememberMe',
      'auth_token', 'auth_user', 'auth_permissions', 'auth_menus'
    ]
    
    keysToRemove.forEach(key => {
      localStorage.removeItem(key)
      sessionStorage.removeItem(key)
    })
    
    // 返回成功
    return Promise.resolve({ success: true, message: '登出成功' })
  }
  
  // 验证token是否有效
  const validateToken = () => {
    if (!token.value) {
      return false
    }
    
    try {
      // 简单的token格式验证（JWT格式：header.payload.signature）
      const parts = token.value.split('.')
      if (parts.length !== 3) {
        logout()
        return false
      }
      
      // 这里可以添加更复杂的token验证逻辑
      // 比如检查token是否过期等
      return true
    } catch (error) {
      logout()
      return false
    }
  }
  
  // 初始化时验证token
  const initAuth = () => {
    if (!validateToken()) {
      logout()
    }
  }
  
  // 初始化
  initAuth()
  
  // 强制刷新用户权限和菜单（增强函数）
  const refreshUserData = async () => {
    try {
      // 先完全清理权限状态
      permissions.value = []
      menus.value = []
      
      // 重新获取用户权限和菜单
      await fetchUserPermissions()
      await fetchUserMenus()
      await fetchUserRoles()
      
      return true
    } catch (error) {
      console.error('刷新用户数据失败:', error)
      return false
    }
  }

  // 强制权限状态重置（新增函数）
  const forceResetPermissionState = () => {
    // 强制重置所有权限相关状态
    permissions.value = []
    menus.value = []
    
    // 清理所有存储
    const allKeys = [
      'token', 'user', 'permissions', 'menus', 'rememberMe',
      'auth_token', 'auth_user', 'auth_permissions', 'auth_menus'
    ]
    
    allKeys.forEach(key => {
      localStorage.removeItem(key)
      sessionStorage.removeItem(key)
    })
    
    // 清理所有可能的权限相关键
    const allLocalKeys = Object.keys(localStorage)
    allLocalKeys.forEach(key => {
      if (key.includes('permission') || key.includes('auth') || key.includes('token') || key.includes('user') || key.includes('menu')) {
        localStorage.removeItem(key)
      }
    })
    
    const allSessionKeys = Object.keys(sessionStorage)
    allSessionKeys.forEach(key => {
      if (key.includes('permission') || key.includes('auth') || key.includes('token') || key.includes('user') || key.includes('menu')) {
        sessionStorage.removeItem(key)
      }
    })
    
    console.log('权限状态重置完成')
  }

  // 验证权限状态是否有效（新增函数）
  const validatePermissionState = () => {
    // 检查权限数据是否与当前用户匹配
    if (!user.value || !user.value.username) {
      return false
    }
    
    // 检查权限数据是否为空
    if (!permissions.value || permissions.value.length === 0) {
      return false
    }
    
    // 检查token是否存在
    if (!token.value) {
      return false
    }
    
    return true
  }

  // 强制清理并重新获取权限（新增函数）
  const forceRefreshPermissions = async () => {
    try {
      // 完全清理权限状态
      clearAuthData()
      
      // 重新获取权限
      await fetchUserPermissions()
      await fetchUserMenus()
      return true
    } catch (error) {
      console.error('强制刷新权限失败:', error)
      return false
    }
  }
  
  // 强制重置所有权限状态（新增函数）
  const forceResetPermissions = () => {
    console.log('强制重置所有权限状态...')
    
    // 强制重置内存状态
    token.value = ''
    user.value = {}
    permissions.value = []
    menus.value = []
    
    // 清理所有存储
    const allKeys = [
      'token', 'user', 'permissions', 'menus', 'rememberMe',
      'auth_token', 'auth_user', 'auth_permissions', 'auth_menus'
    ]
    
    allKeys.forEach(key => {
      localStorage.removeItem(key)
      sessionStorage.removeItem(key)
    })
    
    console.log('权限状态强制重置完成')
  }

  // 检查权限缓存状态（新增函数，用于调试）
  const checkPermissionCache = () => {
    console.log('=== 权限缓存状态检查 ===')
    console.log('内存状态:')
    console.log('  token:', token.value ? '存在' : '不存在')
    console.log('  user:', user.value && Object.keys(user.value).length > 0 ? '存在' : '不存在')
    console.log('  permissions:', permissions.value && permissions.value.length > 0 ? `存在 ${permissions.value.length} 个` : '不存在')
    console.log('  menus:', menus.value && menus.value.length > 0 ? `存在 ${menus.value.length} 个` : '不存在')
    
    console.log('localStorage:')
    console.log('  token:', localStorage.getItem('token') ? '存在' : '不存在')
    console.log('  user:', localStorage.getItem('user') ? '存在' : '不存在')
    console.log('  permissions:', localStorage.getItem('permissions') ? '存在' : '不存在')
    console.log('  menus:', localStorage.getItem('menus') ? '存在' : '不存在')
    console.log('  rememberMe:', localStorage.getItem('rememberMe') ? '存在' : '不存在')
    
    console.log('sessionStorage:')
    console.log('  token:', sessionStorage.getItem('token') ? '存在' : '不存在')
    console.log('  user:', sessionStorage.getItem('user') ? '存在' : '不存在')
    console.log('  permissions:', sessionStorage.getItem('permissions') ? '存在' : '不存在')
    console.log('  menus:', sessionStorage.getItem('menus') ? '存在' : '不存在')
    console.log('=== 检查完成 ===')
  }
  
  // 强制权限验证（新增函数，用于调试）
  const validatePermissions = () => {
    console.log('=== 强制权限验证 ===')
    console.log('当前用户:', user.value?.username)
    console.log('当前token:', token.value ? '存在' : '不存在')
    console.log('当前权限数量:', permissions.value?.length || 0)
    console.log('当前权限列表:', permissions.value)
    
    // 检查关键权限
    const keyPermissions = [
      'system:user:add',
      'system:user:edit', 
      'system:user:delete',
      'system:user:query',
      'system:role:add',
      'system:role:edit',
      'system:role:delete',
      'system:role:query',
      'system:permission:add',
      'system:permission:edit',
      'system:permission:delete',
      'system:permission:query'
    ]
    
    const permissionCheck = {}
    keyPermissions.forEach(perm => {
      permissionCheck[perm] = permissions.value?.includes(perm) || false
    })
    
    console.log('关键权限检查结果:', permissionCheck)
    console.log('=== 权限验证完成 ===')
    
    return permissionCheck
  }

  // 强制重新获取权限（新增函数）
  const forceReFetchPermissions = async () => {
    console.log('=== 强制重新获取权限 ===')
    
    try {
      // 完全清理权限状态
      permissions.value = []
      menus.value = []
      
      // 重新获取
      await fetchUserPermissions()
      await fetchUserMenus()
      
      // 验证结果
      validatePermissions()
      
      return true
    } catch (error) {
      console.error('强制重新获取权限失败:', error)
      return false
    }
  }
  
  return {
    token,
    user,
    permissions,
    menus,
    isAuthenticated,
    isLoggedIn,
    login,
    logout,
    clearAuthData,
    fetchUserPermissions,
    fetchUserMenus,
    refreshUserData,
    forceRefreshPermissions,
    validatePermissionState,
    hasPermission,
    hasAnyPermission,
    hasAllPermissions,
    forceResetPermissions,
    forceResetPermissionState,
    validatePermissions,
    forceReFetchPermissions,
    checkPermissionCache
  }
}) 